package factorymethod

//工厂方法模式使用子类的方式 延迟生成对象到子类中实现
//Go中不存在继承 所以使用匿名组合的方式 关闭 一个 <- close
//倒入数据 关闭 有缓存 管道没有 去取 堵塞 管道满了 去放置堵塞 管道关闭 写会panic 管道关闭读取 自动关闭range 堵塞
// Operator 是被封装的实际类接口 工厂方法
type Operator interface {
	SetA(int)
	SetB(int)
	Result() int
}

//Operatorfactory 是工厂接口
type Operatorfactory interface {
	Crate() Operator
}

// OperatorBase 是 operator 接口的实现的基础类 封装公用方法 组合 继承 多态 封装 闭包 组合 肚子 拥有
//内在 学习
type OperatorBase struct {
	a, b int
}

func (o *OperatorBase) SetA(a int) {
	o.a = a
}
func (o *OperatorBase) SetB(b int) {
	o.b = b
}

//Plusopereatorfactoy 是 PlusOperator 的工厂类 该结构实现了 OperatorFactoy 接口
type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Crate() Operator {
	return &PlusOperator{
		&OperatorBase{},
	}
}

type PlusOperator struct {
	*OperatorBase
}

func (o PlusOperator) Result() int {
	return o.a + o.b
}

type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Crate() Operator {
	return &MiunsOperator{
		&OperatorBase{},
	}
}

type MiunsOperator struct {
	*OperatorBase
}

func (o *MiunsOperator) Result() int {
	return o.a - o.b
}

type SinOperatorFactory struct{}

func (SinOperatorFactory) Crate() Operator {
	return &SinOperator{
		&OperatorBase{},
	}
}

type SinOperator struct {
	*OperatorBase
}

func (o *SinOperator) Result() int {
	return o.a * o.b
}
